Termination w.r.t. Q proof of /home/nowonder/forschung/aprove/satrung/aprove/lpar16/nonterminSLASHAG01SLASHHASH4.36.trs

Termination w.r.t. Q of the following Term Rewriting System could be proven:

Q restricted rewrite system:
The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

Q is empty.

↳ QTRS

  ↳ Non-Overlap Check

Q restricted rewrite system:
The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

Q is empty.

The TRS is non-overlapping. Hence, we can switch to innermost.

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

The set Q consists of the following terms:

eq₂(0, 0)
eq₂(0, s₁(x0))
eq₂(s₁(x0), 0)
eq₂(s₁(x0), s₁(x1))
le₂(0, x0)
le₂(s₁(x0), 0)
le₂(s₁(x0), s₁(x1))
min₁(cons₂(0, nil))
min₁(cons₂(s₁(x0), nil))
min₁(cons₂(x0, cons₂(x1, x2)))
if_min₂(true, cons₂(x0, cons₂(x1, x2)))
if_min₂(false, cons₂(x0, cons₂(x1, x2)))
replace₃(x0, x1, nil)
replace₃(x0, x1, cons₂(x2, x3))
if_replace₄(true, x0, x1, cons₂(x2, x3))
if_replace₄(false, x0, x1, cons₂(x2, x3))
sort₁(nil)
sort₁(cons₂(x0, x1))

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

REPLACE₃(n, m, cons₂(k, x)) -> IF_REPLACE₄(eq₂(n, k), n, m, cons₂(k, x))
EQ₂(s₁(n), s₁(m)) -> EQ₂(n, m)
SORT₁(cons₂(n, x)) -> REPLACE₃(min₁(cons₂(n, x)), n, x)
MIN₁(cons₂(n, cons₂(m, x))) -> LE₂(n, m)
LE₂(s₁(n), s₁(m)) -> LE₂(n, m)
SORT₁(cons₂(n, x)) -> MIN₁(cons₂(n, x))
REPLACE₃(n, m, cons₂(k, x)) -> EQ₂(n, k)
SORT₁(cons₂(n, x)) -> SORT₁(replace₃(min₁(cons₂(n, x)), n, x))
IF_MIN₂(true, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(n, x))
MIN₁(cons₂(n, cons₂(m, x))) -> IF_MIN₂(le₂(n, m), cons₂(n, cons₂(m, x)))
IF_MIN₂(false, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(m, x))
IF_REPLACE₄(false, n, m, cons₂(k, x)) -> REPLACE₃(n, m, x)

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

The set Q consists of the following terms:

eq₂(0, 0)
eq₂(0, s₁(x0))
eq₂(s₁(x0), 0)
eq₂(s₁(x0), s₁(x1))
le₂(0, x0)
le₂(s₁(x0), 0)
le₂(s₁(x0), s₁(x1))
min₁(cons₂(0, nil))
min₁(cons₂(s₁(x0), nil))
min₁(cons₂(x0, cons₂(x1, x2)))
if_min₂(true, cons₂(x0, cons₂(x1, x2)))
if_min₂(false, cons₂(x0, cons₂(x1, x2)))
replace₃(x0, x1, nil)
replace₃(x0, x1, cons₂(x2, x3))
if_replace₄(true, x0, x1, cons₂(x2, x3))
if_replace₄(false, x0, x1, cons₂(x2, x3))
sort₁(nil)
sort₁(cons₂(x0, x1))

We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

REPLACE₃(n, m, cons₂(k, x)) -> IF_REPLACE₄(eq₂(n, k), n, m, cons₂(k, x))
EQ₂(s₁(n), s₁(m)) -> EQ₂(n, m)
SORT₁(cons₂(n, x)) -> REPLACE₃(min₁(cons₂(n, x)), n, x)
MIN₁(cons₂(n, cons₂(m, x))) -> LE₂(n, m)
LE₂(s₁(n), s₁(m)) -> LE₂(n, m)
SORT₁(cons₂(n, x)) -> MIN₁(cons₂(n, x))
REPLACE₃(n, m, cons₂(k, x)) -> EQ₂(n, k)
SORT₁(cons₂(n, x)) -> SORT₁(replace₃(min₁(cons₂(n, x)), n, x))
IF_MIN₂(true, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(n, x))
MIN₁(cons₂(n, cons₂(m, x))) -> IF_MIN₂(le₂(n, m), cons₂(n, cons₂(m, x)))
IF_MIN₂(false, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(m, x))
IF_REPLACE₄(false, n, m, cons₂(k, x)) -> REPLACE₃(n, m, x)

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

The set Q consists of the following terms:

eq₂(0, 0)
eq₂(0, s₁(x0))
eq₂(s₁(x0), 0)
eq₂(s₁(x0), s₁(x1))
le₂(0, x0)
le₂(s₁(x0), 0)
le₂(s₁(x0), s₁(x1))
min₁(cons₂(0, nil))
min₁(cons₂(s₁(x0), nil))
min₁(cons₂(x0, cons₂(x1, x2)))
if_min₂(true, cons₂(x0, cons₂(x1, x2)))
if_min₂(false, cons₂(x0, cons₂(x1, x2)))
replace₃(x0, x1, nil)
replace₃(x0, x1, cons₂(x2, x3))
if_replace₄(true, x0, x1, cons₂(x2, x3))
if_replace₄(false, x0, x1, cons₂(x2, x3))
sort₁(nil)
sort₁(cons₂(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 5 SCCs with 4 less nodes.

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ QDPOrderProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

LE₂(s₁(n), s₁(m)) -> LE₂(n, m)

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

The set Q consists of the following terms:

eq₂(0, 0)
eq₂(0, s₁(x0))
eq₂(s₁(x0), 0)
eq₂(s₁(x0), s₁(x1))
le₂(0, x0)
le₂(s₁(x0), 0)
le₂(s₁(x0), s₁(x1))
min₁(cons₂(0, nil))
min₁(cons₂(s₁(x0), nil))
min₁(cons₂(x0, cons₂(x1, x2)))
if_min₂(true, cons₂(x0, cons₂(x1, x2)))
if_min₂(false, cons₂(x0, cons₂(x1, x2)))
replace₃(x0, x1, nil)
replace₃(x0, x1, cons₂(x2, x3))
if_replace₄(true, x0, x1, cons₂(x2, x3))
if_replace₄(false, x0, x1, cons₂(x2, x3))
sort₁(nil)
sort₁(cons₂(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

LE₂(s₁(n), s₁(m)) -> LE₂(n, m)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
LE₂(x1, x2) = LE₁(x1)
s₁(x1) = s₁(x1)

Lexicographic Path Order [19].
Precedence:

trivial

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

The set Q consists of the following terms:

eq₂(0, 0)
eq₂(0, s₁(x0))
eq₂(s₁(x0), 0)
eq₂(s₁(x0), s₁(x1))
le₂(0, x0)
le₂(s₁(x0), 0)
le₂(s₁(x0), s₁(x1))
min₁(cons₂(0, nil))
min₁(cons₂(s₁(x0), nil))
min₁(cons₂(x0, cons₂(x1, x2)))
if_min₂(true, cons₂(x0, cons₂(x1, x2)))
if_min₂(false, cons₂(x0, cons₂(x1, x2)))
replace₃(x0, x1, nil)
replace₃(x0, x1, cons₂(x2, x3))
if_replace₄(true, x0, x1, cons₂(x2, x3))
if_replace₄(false, x0, x1, cons₂(x2, x3))
sort₁(nil)
sort₁(cons₂(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF_MIN₂(true, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(n, x))
MIN₁(cons₂(n, cons₂(m, x))) -> IF_MIN₂(le₂(n, m), cons₂(n, cons₂(m, x)))
IF_MIN₂(false, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(m, x))

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

The set Q consists of the following terms:

eq₂(0, 0)
eq₂(0, s₁(x0))
eq₂(s₁(x0), 0)
eq₂(s₁(x0), s₁(x1))
le₂(0, x0)
le₂(s₁(x0), 0)
le₂(s₁(x0), s₁(x1))
min₁(cons₂(0, nil))
min₁(cons₂(s₁(x0), nil))
min₁(cons₂(x0, cons₂(x1, x2)))
if_min₂(true, cons₂(x0, cons₂(x1, x2)))
if_min₂(false, cons₂(x0, cons₂(x1, x2)))
replace₃(x0, x1, nil)
replace₃(x0, x1, cons₂(x2, x3))
if_replace₄(true, x0, x1, cons₂(x2, x3))
if_replace₄(false, x0, x1, cons₂(x2, x3))
sort₁(nil)
sort₁(cons₂(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

IF_MIN₂(true, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(n, x))
IF_MIN₂(false, cons₂(n, cons₂(m, x))) -> MIN₁(cons₂(m, x))

The remaining pairs can at least by weakly be oriented.

MIN₁(cons₂(n, cons₂(m, x))) -> IF_MIN₂(le₂(n, m), cons₂(n, cons₂(m, x)))

Used ordering: Combined order from the following AFS and order.
IF_MIN₂(x1, x2) = x2
true = true
cons₂(x1, x2) = cons₁(x2)
MIN₁(x1) = x1
le₂(x1, x2) = le
false = false
0 = 0
s₁(x1) = s

Lexicographic Path Order [19].
Precedence:

[cons₁, le] > [true, false, 0, s]

The following usable rules [14] were oriented:

le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ DependencyGraphProof

              ↳ QDP

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

MIN₁(cons₂(n, cons₂(m, x))) -> IF_MIN₂(le₂(n, m), cons₂(n, cons₂(m, x)))

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

The set Q consists of the following terms:

eq₂(0, 0)
eq₂(0, s₁(x0))
eq₂(s₁(x0), 0)
eq₂(s₁(x0), s₁(x1))
le₂(0, x0)
le₂(s₁(x0), 0)
le₂(s₁(x0), s₁(x1))
min₁(cons₂(0, nil))
min₁(cons₂(s₁(x0), nil))
min₁(cons₂(x0, cons₂(x1, x2)))
if_min₂(true, cons₂(x0, cons₂(x1, x2)))
if_min₂(false, cons₂(x0, cons₂(x1, x2)))
replace₃(x0, x1, nil)
replace₃(x0, x1, cons₂(x2, x3))
if_replace₄(true, x0, x1, cons₂(x2, x3))
if_replace₄(false, x0, x1, cons₂(x2, x3))
sort₁(nil)
sort₁(cons₂(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 0 SCCs with 1 less node.

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

              ↳ QDP

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

EQ₂(s₁(n), s₁(m)) -> EQ₂(n, m)

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

The set Q consists of the following terms:

eq₂(0, 0)
eq₂(0, s₁(x0))
eq₂(s₁(x0), 0)
eq₂(s₁(x0), s₁(x1))
le₂(0, x0)
le₂(s₁(x0), 0)
le₂(s₁(x0), s₁(x1))
min₁(cons₂(0, nil))
min₁(cons₂(s₁(x0), nil))
min₁(cons₂(x0, cons₂(x1, x2)))
if_min₂(true, cons₂(x0, cons₂(x1, x2)))
if_min₂(false, cons₂(x0, cons₂(x1, x2)))
replace₃(x0, x1, nil)
replace₃(x0, x1, cons₂(x2, x3))
if_replace₄(true, x0, x1, cons₂(x2, x3))
if_replace₄(false, x0, x1, cons₂(x2, x3))
sort₁(nil)
sort₁(cons₂(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

EQ₂(s₁(n), s₁(m)) -> EQ₂(n, m)

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
EQ₂(x1, x2) = EQ₁(x1)
s₁(x1) = s₁(x1)

Lexicographic Path Order [19].
Precedence:

trivial

The following usable rules [14] were oriented: none

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

              ↳ QDP

              ↳ QDP

Q DP problem:
P is empty.
The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

The set Q consists of the following terms:

eq₂(0, 0)
eq₂(0, s₁(x0))
eq₂(s₁(x0), 0)
eq₂(s₁(x0), s₁(x1))
le₂(0, x0)
le₂(s₁(x0), 0)
le₂(s₁(x0), s₁(x1))
min₁(cons₂(0, nil))
min₁(cons₂(s₁(x0), nil))
min₁(cons₂(x0, cons₂(x1, x2)))
if_min₂(true, cons₂(x0, cons₂(x1, x2)))
if_min₂(false, cons₂(x0, cons₂(x1, x2)))
replace₃(x0, x1, nil)
replace₃(x0, x1, cons₂(x2, x3))
if_replace₄(true, x0, x1, cons₂(x2, x3))
if_replace₄(false, x0, x1, cons₂(x2, x3))
sort₁(nil)
sort₁(cons₂(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

REPLACE₃(n, m, cons₂(k, x)) -> IF_REPLACE₄(eq₂(n, k), n, m, cons₂(k, x))
IF_REPLACE₄(false, n, m, cons₂(k, x)) -> REPLACE₃(n, m, x)

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

The set Q consists of the following terms:

eq₂(0, 0)
eq₂(0, s₁(x0))
eq₂(s₁(x0), 0)
eq₂(s₁(x0), s₁(x1))
le₂(0, x0)
le₂(s₁(x0), 0)
le₂(s₁(x0), s₁(x1))
min₁(cons₂(0, nil))
min₁(cons₂(s₁(x0), nil))
min₁(cons₂(x0, cons₂(x1, x2)))
if_min₂(true, cons₂(x0, cons₂(x1, x2)))
if_min₂(false, cons₂(x0, cons₂(x1, x2)))
replace₃(x0, x1, nil)
replace₃(x0, x1, cons₂(x2, x3))
if_replace₄(true, x0, x1, cons₂(x2, x3))
if_replace₄(false, x0, x1, cons₂(x2, x3))
sort₁(nil)
sort₁(cons₂(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

REPLACE₃(n, m, cons₂(k, x)) -> IF_REPLACE₄(eq₂(n, k), n, m, cons₂(k, x))

The remaining pairs can at least by weakly be oriented.

IF_REPLACE₄(false, n, m, cons₂(k, x)) -> REPLACE₃(n, m, x)

Used ordering: Combined order from the following AFS and order.
REPLACE₃(x1, x2, x3) = REPLACE₁(x3)
cons₂(x1, x2) = cons₁(x2)
IF_REPLACE₄(x1, x2, x3, x4) = x4
eq₂(x1, x2) = eq₁(x2)
false = false
0 = 0
true = true
s₁(x1) = x1

Lexicographic Path Order [19].
Precedence:

[REPLACE₁, cons_1] > eq₁ > false
[REPLACE₁, cons_1] > eq₁ > true
0 > false
0 > true

The following usable rules [14] were oriented:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ DependencyGraphProof

              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

IF_REPLACE₄(false, n, m, cons₂(k, x)) -> REPLACE₃(n, m, x)

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

The set Q consists of the following terms:

eq₂(0, 0)
eq₂(0, s₁(x0))
eq₂(s₁(x0), 0)
eq₂(s₁(x0), s₁(x1))
le₂(0, x0)
le₂(s₁(x0), 0)
le₂(s₁(x0), s₁(x1))
min₁(cons₂(0, nil))
min₁(cons₂(s₁(x0), nil))
min₁(cons₂(x0, cons₂(x1, x2)))
if_min₂(true, cons₂(x0, cons₂(x1, x2)))
if_min₂(false, cons₂(x0, cons₂(x1, x2)))
replace₃(x0, x1, nil)
replace₃(x0, x1, cons₂(x2, x3))
if_replace₄(true, x0, x1, cons₂(x2, x3))
if_replace₄(false, x0, x1, cons₂(x2, x3))
sort₁(nil)
sort₁(cons₂(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 0 SCCs with 1 less node.

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

SORT₁(cons₂(n, x)) -> SORT₁(replace₃(min₁(cons₂(n, x)), n, x))

The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

The set Q consists of the following terms:

eq₂(0, 0)
eq₂(0, s₁(x0))
eq₂(s₁(x0), 0)
eq₂(s₁(x0), s₁(x1))
le₂(0, x0)
le₂(s₁(x0), 0)
le₂(s₁(x0), s₁(x1))
min₁(cons₂(0, nil))
min₁(cons₂(s₁(x0), nil))
min₁(cons₂(x0, cons₂(x1, x2)))
if_min₂(true, cons₂(x0, cons₂(x1, x2)))
if_min₂(false, cons₂(x0, cons₂(x1, x2)))
replace₃(x0, x1, nil)
replace₃(x0, x1, cons₂(x2, x3))
if_replace₄(true, x0, x1, cons₂(x2, x3))
if_replace₄(false, x0, x1, cons₂(x2, x3))
sort₁(nil)
sort₁(cons₂(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be strictly oriented and are deleted.

SORT₁(cons₂(n, x)) -> SORT₁(replace₃(min₁(cons₂(n, x)), n, x))

The remaining pairs can at least by weakly be oriented.
none
Used ordering: Combined order from the following AFS and order.
SORT₁(x1) = SORT₁(x1)
cons₂(x1, x2) = cons₁(x2)
replace₃(x1, x2, x3) = x3
min₁(x1) = min
0 = 0
nil = nil
s₁(x1) = s
if_min₂(x1, x2) = x1
false = false
le₂(x1, x2) = le
true = true
if_replace₄(x1, x2, x3, x4) = x4
eq₂(x1, x2) = eq

Lexicographic Path Order [19].
Precedence:

cons₁ > SORT₁ > [min, s, false, le, true] > 0
nil > 0
eq > [min, s, false, le, true] > 0

The following usable rules [14] were oriented:

min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)

↳ QTRS

  ↳ Non-Overlap Check

    ↳ QTRS

      ↳ DependencyPairsProof

        ↳ QDP

          ↳ DependencyGraphProof

            ↳ AND

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

              ↳ QDP

                ↳ QDPOrderProof

                  ↳ QDP

                    ↳ PisEmptyProof

Q DP problem:
P is empty.
The TRS R consists of the following rules:

eq₂(0, 0) -> true
eq₂(0, s₁(m)) -> false
eq₂(s₁(n), 0) -> false
eq₂(s₁(n), s₁(m)) -> eq₂(n, m)
le₂(0, m) -> true
le₂(s₁(n), 0) -> false
le₂(s₁(n), s₁(m)) -> le₂(n, m)
min₁(cons₂(0, nil)) -> 0
min₁(cons₂(s₁(n), nil)) -> s₁(n)
min₁(cons₂(n, cons₂(m, x))) -> if_min₂(le₂(n, m), cons₂(n, cons₂(m, x)))
if_min₂(true, cons₂(n, cons₂(m, x))) -> min₁(cons₂(n, x))
if_min₂(false, cons₂(n, cons₂(m, x))) -> min₁(cons₂(m, x))
replace₃(n, m, nil) -> nil
replace₃(n, m, cons₂(k, x)) -> if_replace₄(eq₂(n, k), n, m, cons₂(k, x))
if_replace₄(true, n, m, cons₂(k, x)) -> cons₂(m, x)
if_replace₄(false, n, m, cons₂(k, x)) -> cons₂(k, replace₃(n, m, x))
sort₁(nil) -> nil
sort₁(cons₂(n, x)) -> cons₂(min₁(cons₂(n, x)), sort₁(replace₃(min₁(cons₂(n, x)), n, x)))

The set Q consists of the following terms:

eq₂(0, 0)
eq₂(0, s₁(x0))
eq₂(s₁(x0), 0)
eq₂(s₁(x0), s₁(x1))
le₂(0, x0)
le₂(s₁(x0), 0)
le₂(s₁(x0), s₁(x1))
min₁(cons₂(0, nil))
min₁(cons₂(s₁(x0), nil))
min₁(cons₂(x0, cons₂(x1, x2)))
if_min₂(true, cons₂(x0, cons₂(x1, x2)))
if_min₂(false, cons₂(x0, cons₂(x1, x2)))
replace₃(x0, x1, nil)
replace₃(x0, x1, cons₂(x2, x3))
if_replace₄(true, x0, x1, cons₂(x2, x3))
if_replace₄(false, x0, x1, cons₂(x2, x3))
sort₁(nil)
sort₁(cons₂(x0, x1))

We have to consider all minimal (P,Q,R)-chains.
The TRS P is empty. Hence, there is no (P,Q,R) chain.